// 版权所有2012 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 此文件实现对语句的类型检查。

package types

import (
	"go/ast"
	"go/constant"
	"go/token"
	"sort"
)

func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt, iota constant.Value) {
	if check.conf.IgnoreFuncBodies {
		panic("function body not ignored")
	}

	if trace {
		check.trace(body.Pos(), "--- %s: %s", name, sig)
		defer func() {
			check.trace(body.End(), "--- <end>")
		}()
	}

	// 设置函数作用域范围
	sig.scope.pos = body.Pos()
	sig.scope.end = body.End()

	// 保存/恢复当前环境并设置函数环境
	// （并在函数开始时使用0缩进）
	defer func(env environment, indent int) {
		check.environment = env
		check.indent = indent
	}(check.environment, check.indent)
	check.environment = environment{
		decl:  decl,
		scope: sig.scope,
		iota:  iota,
		sig:   sig,
	}
	check.indent = 0

	check.stmtList(0, body.List)

	if check.hasLabel {
		check.labels(body)
	}

	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
		check.error(atPos(body.Rbrace), _MissingReturn, "missing return")
	}

	// 规范：“实现限制：如果从未使用变量，编译器可能会将
	// 在函数体中声明变量设置为非法。”
	check.usage(sig.scope)
}

func (check *Checker) usage(scope *Scope) {
	var unused []*Var
	for name, elem := range scope.elems {
		elem = resolve(name, elem)
		if v, _ := elem.(*Var); v != nil && !v.used {
			unused = append(unused, v)
		}
	}
	sort.Slice(unused, func(i, j int) bool {
		return unused[i].pos < unused[j].pos
	})
	for _, v := range unused {
		check.softErrorf(v, _UnusedVar, "%s declared but not used", v.name)
	}

	for _, scope := range scope.children {
		// 不要第二次进入函数文字范围；
		// 它们由funcBody显式处理。
		if !scope.isFunc {
			check.usage(scope)
		}
	}
}

// stmtContext是一个位集，描述允许使用哪个
// 控制流语句，
// 并提供额外的上下文信息
// 以获得更好的错误消息。
type stmtContext uint

const (
	// 允许的控制流语句
	breakOk stmtContext = 1 << iota
	continueOk
	fallthroughOk

	// 附加上下文信息
	finalSwitchCase
)

func (check *Checker) simpleStmt(s ast.Stmt) {
	if s != nil {
		check.stmt(0, s)
	}
}

func trimTrailingEmptyStmts(list []ast.Stmt) []ast.Stmt {
	for i := len(list); i > 0; i-- {
		if _, ok := list[i-1].(*ast.EmptyStmt); !ok {
			return list[:i]
		}
	}
	return nil
}

func (check *Checker) stmtList(ctxt stmtContext, list []ast.Stmt) {
	ok := ctxt&fallthroughOk != 0
	inner := ctxt &^ fallthroughOk
	list = trimTrailingEmptyStmts(list) // 尾部空语句对于故障分析
	for i, s := range list {
		inner := inner
		if ok && i+1 == len(list) {
			inner |= fallthroughOk
		}
		check.stmt(inner, s)
	}
}

func (check *Checker) multipleDefaults(list []ast.Stmt) {
	var first ast.Stmt
	for _, s := range list {
		var d ast.Stmt
		switch c := s.(type) {
		case *ast.CaseClause:
			if len(c.List) == 0 {
				d = s
			}
		case *ast.CommClause:
			if c.Comm == nil {
				d = s
			}
		default:
			check.invalidAST(s, "case/communication clause expected")
		}
		if d != nil {
			if first != nil {
				check.errorf(d, _DuplicateDefault, "multiple defaults (first at %s)", check.fset.Position(first.Pos()))
			} else {
				first = d
			}
		}
	}
}

func (check *Checker) openScope(node ast.Node, comment string) {
	scope := NewScope(check.scope, node.Pos(), node.End(), comment)
	check.recordScope(node, scope)
	check.scope = scope
}

func (check *Checker) closeScope() {
	check.scope = check.scope.Parent()
}

func assignOp(op token.Token) token.Token {
	// 令牌测试是“不可见的”。go验证令牌顺序此函数依赖于
	if token.ADD_ASSIGN <= op && op <= token.AND_NOT_ASSIGN {
		return op + (token.ADD - token.ADD_ASSIGN)
	}
	return token.ILLEGAL
}

func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) {
	var x operand
	var msg string
	var code errorCode
	switch check.rawExpr(&x, call, nil, false) {
	case conversion:
		msg = "requires function call, not conversion"
		code = _InvalidDefer
		if keyword == "go" {
			code = _InvalidGo
		}
	case expression:
		msg = "discards result of"
		code = _UnusedResults
	case statement:
		return
	default:
		unreachable()
	}
	check.errorf(&x, code, "%s %s %s", keyword, msg, &x)
}

// goVal返回val的go值，或nil。
func goVal(val constant.Value) any {
	// val应该存在，但要保守，请检查
	if val == nil {
		return nil
	}
	// 是否匹配其他编译器的实现限制。
	// gc只检查整数、浮点
	// 和字符串值的重复项，所以只为这些
	// 类型创建Go值。
	switch val.Kind() {
	case constant.Int:
		if x, ok := constant.Int64Val(val); ok {
			return x
		}
		if x, ok := constant.Uint64Val(val); ok {
			return x
		}
	case constant.Float:
		if x, ok := constant.Float64Val(val); ok {
			return x
		}
	case constant.String:
		return constant.StringVal(val)
	}
	return nil
}

// valueMap将一个案例值（基本Go类型）映射到一个位置列表
// ，其中出现了相同的案例值，以及相应的案例
// 类型。
// 由于两个case值可能具有相同的“基础”值，但不同的
// 类型，我们还需要检查值的类型（例如字节（1）与myByte（1））
// 当开关表达式为接口类型时。
type (
	valueMap  map[any][]valueType // 基础Go值->值类型
	valueType struct {
		pos token.Pos
		typ Type
	}
)

func (check *Checker) caseValues(x *operand, values []ast.Expr, seen valueMap) {
L:
	for _, e := range values {
		var v operand
		check.expr(&v, e)
		if x.mode == invalid || v.mode == invalid {
			continue L
		}
		check.convertUntyped(&v, x.typ)
		if v.mode == invalid {
			continue L
		}
		// 顺序事项：通过比较v和x，错误位置位于大小写值处。
		res := v // 保持原始v不变
		check.comparison(&res, x, token.EQL, true)
		if res.mode == invalid {
			continue L
		}
		if v.mode != constant_ {
			continue L // 我们完成了
		}
		// 查找重复值
		if val := goVal(v.val); val != nil {
			// 查找给定值的重复类型
			// （二次算法，但这些列表往往很短）
			for _, vt := range seen[val] {
				if Identical(v.typ, vt.typ) {
					check.errorf(&v, _DuplicateCase, "duplicate case %s in expression switch", &v)
					check.error(atPos(vt.pos), _DuplicateCase, "\tprevious case") // 次要错误，\t缩进的
					continue L
				}
			}
			seen[val] = append(seen[val], valueType{v.Pos(), v.typ})
		}
	}
}

// isNil报告表达式e是否表示预先声明的值nil。
func (check *Checker) isNil(e ast.Expr) bool {
	// 表示nil值的唯一方法是直接写nil（可能在括号中）。
	if name, _ := unparen(e).(*ast.Ident); name != nil {
		_, ok := check.lookup(name.Name).(*Nil)
		return ok
	}
	return false
}

// 如果类型开关表达式无效，则x为零。
func (check *Checker) caseTypes(x *operand, types []ast.Expr, seen map[Type]ast.Expr) (T Type) {
	var dummy operand
L:
	for _, e := range types {
		// 规范允许值nil而不是类型。
		if check.isNil(e) {
			T = nil
			check.expr(&dummy, e) // 通过expr运行e，这样我们就可以得到通常的信息记录
		} else {
			T = check.varType(e)
			if T == Typ[Invalid] {
				continue L
			}
		}
		// 寻找重复类型
		// （二次算法，但类型开关往往相当小）
		for t, other := range seen {
			if T == nil && t == nil || T != nil && t != nil && Identical(T, t) {
				// 谈论“case”而不是“type”，因为无case 
				Ts := "nil"
				if T != nil {
					Ts = TypeString(T, check.qualifier)
				}
				check.errorf(e, _DuplicateCase, "duplicate case %s in type switch", Ts)
				check.error(other, _DuplicateCase, "\tprevious case") // 二次错误，\t缩进
				continue L
			}
		}
		seen[T] = e
		if x != nil && T != nil {
			check.typeAssertion(e, x, T, true)
		}
	}
	return
}

// TODO（gri）一旦我们确定typeHash在所有情况下都是正确的，请使用此版本的caseTypes。
// （由于ImporterFrom，目前可能不同类型具有相同的名称和导入路径。）
// 
// func（check*Checker）caseTypes（x*操作数，xtyp*接口，类型[]ast.Expr，seen map[string]ast.Expr（T Type）{
// var伪操作数
// L:
// for 2;，e:=范围类型{
// /规范允许使用值nil而不是类型。
// var hash string 
// if check.isNil（e）{
// check.expr（&dummy，e）
// T=nil 
// T=check.varType（e）
// if T==Typ[Invalid]{
// continue L 
// }
// hash=typeHash（T，nil）
// }
// /寻找重复的类型
// /如果其他：=seed[hash]；其他！=nil{
// /谈论“case”而不是“type”，因为nil case 
// Ts:=“nil”
// /如果T！=nil{
// Ts=TypeString（T，check.qualifier）
// }
// /var error_0;
// 错误。errorf（其他，“先前案例”）
// 检查。报告（&err）
// 继续L 
// /}
// 看到[hash]=e 
// 如果T！=nil{
// check.typeAssertion（e.Pos（），x，xtyp，T）
// }
// }
// /返回
// }

// stmt typechecks语句。
func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
	// 语句必须以与
	if debug {
		defer func(scope *Scope) {
			// 开始时相同的顶部范围结束
			if p := recover(); p != nil {
				panic(p)
			}
			assert(scope == check.scope)
		}(check.scope)
	}

	defer check.processDelayed(len(check.delayed))

	inner := ctxt &^ (fallthroughOk | finalSwitchCase)
	switch s := s.(type) {
	case *ast.BadStmt, *ast.EmptyStmt:
		// 忽略

	case *ast.DeclStmt:
		check.declStmt(s.Decl)

	case *ast.LabeledStmt:
		check.hasLabel = true
		check.stmt(ctxt, s.Stmt)

	case *ast.ExprStmt:
		// 规范：“除了特定的内置函数外，
		// 函数和方法调用以及接收操作可以在语句上下文中出现
		// 这样的语句可以用括号括起来。”
		var x operand
		kind := check.rawExpr(&x, s.X, nil, false)
		var msg string
		var code errorCode
		switch x.mode {
		default:
			if kind == statement {
				return
			}
			msg = "is not used"
			code = _UnusedExpr
		case builtin:
			msg = "must be called"
			code = _UncalledBuiltin
		case typexpr:
			msg = "is not an expression"
			code = _NotAnExpr
		}
		check.errorf(&x, code, "%s %s", &x, msg)

	case *ast.SendStmt:
		var ch, val operand
		check.expr(&ch, s.Chan)
		check.expr(&val, s.Value)
		if ch.mode == invalid || val.mode == invalid {
			return
		}
		u := coreType(ch.typ)
		if u == nil {
			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to %s: no core type", &ch)
			return
		}
		uch, _ := u.(*Chan)
		if uch == nil {
			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-channel %s", &ch)
			return
		}
		if uch.dir == RecvOnly {
			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to receive-only channel %s", &ch)
			return
		}
		check.assignment(&val, uch.elem, "send")

	case *ast.IncDecStmt:
		var op token.Token
		switch s.Tok {
		case token.INC:
			op = token.ADD
		case token.DEC:
			op = token.SUB
		default:
			check.invalidAST(inNode(s, s.TokPos), "unknown inc/dec operation %s", s.Tok)
			return
		}

		var x operand
		check.expr(&x, s.X)
		if x.mode == invalid {
			return
		}
		if !allNumeric(x.typ) {
			check.invalidOp(s.X, _NonNumericIncDec, "%s%s (non-numeric type %s)", s.X, s.Tok, x.typ)
			return
		}

		Y := &ast.BasicLit{ValuePos: s.X.Pos(), Kind: token.INT, Value: "1"} // 使用x的位置
		check.binary(&x, nil, s.X, Y, op, s.TokPos)
		if x.mode == invalid {
			return
		}
		check.assignVar(s.X, &x)

	case *ast.AssignStmt:
		switch s.Tok {
		case token.ASSIGN, token.DEFINE:
			if len(s.Lhs) == 0 {
				check.invalidAST(s, "missing lhs in assignment")
				return
			}
			if s.Tok == token.DEFINE {
				check.shortVarDecl(inNode(s, s.TokPos), s.Lhs, s.Rhs)
			} else {
				// 常规赋值
				check.assignVars(s.Lhs, s.Rhs)
			}

		default:
			// 赋值操作
			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {
				check.errorf(inNode(s, s.TokPos), _MultiValAssignOp, "assignment operation %s requires single-valued expressions", s.Tok)
				return
			}
			op := assignOp(s.Tok)
			if op == token.ILLEGAL {
				check.invalidAST(atPos(s.TokPos), "unknown assignment operation %s", s.Tok)
				return
			}
			var x operand
			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op, s.TokPos)
			if x.mode == invalid {
				return
			}
			check.assignVar(s.Lhs[0], &x)
		}

	case *ast.GoStmt:
		check.suspendedCall("go", s.Call)

	case *ast.DeferStmt:
		check.suspendedCall("defer", s.Call)

	case *ast.ReturnStmt:
		res := check.sig.results
		// 返回带有命名结果的函数所允许的隐式结果。
		// /（如果一个被命名，所有的都被命名。）
		if len(s.Results) == 0 && res.Len() > 0 && res.vars[0].name != "" {
			// spec:“实现限制：如果在返回位置的作用域中存在与结果参数同名的不同实体（常量、类型或变量）
			// 列表。”
			// 编译器可能不允许在“return”语句中使用空表达式
			for _, obj := range res.vars {
				if alt := check.lookup(obj.name); alt != nil && alt != obj {
					check.errorf(s, _OutOfScopeResult, "result parameter %s not in scope at return", obj.name)
					check.errorf(alt, _OutOfScopeResult, "\tinner declaration of %s", obj)
					// 确定继续
				}
			}
		} else {
			var lhs []*Var
			if res.Len() > 0 {
				lhs = res.vars
			}
			check.initVars(lhs, s.Results, s)
		}

	case *ast.BranchStmt:
		if s.Label != nil {
			check.hasLabel = true
			return // 第二遍检查（check.labels）
		}
		switch s.Tok {
		case token.BREAK:
			if ctxt&breakOk == 0 {
				check.error(s, _MisplacedBreak, "break not in for, switch, or select statement")
			}
		case token.CONTINUE:
			if ctxt&continueOk == 0 {
				check.error(s, _MisplacedContinue, "continue not in for statement")
			}
		case token.FALLTHROUGH:
			if ctxt&fallthroughOk == 0 {
				msg := "fallthrough statement out of place"
				code := _MisplacedFallthrough
				if ctxt&finalSwitchCase != 0 {
					msg = "cannot fallthrough final case in switch"
				}
				check.error(s, code, msg)
			}
		default:
			check.invalidAST(s, "branch statement: %s", s.Tok)
		}

	case *ast.BlockStmt:
		check.openScope(s, "block")
		defer check.closeScope()

		check.stmtList(inner, s.List)

	case *ast.IfStmt:
		check.openScope(s, "if")
		defer check.closeScope()

		check.simpleStmt(s.Init)
		var x operand
		check.expr(&x, s.Cond)
		if x.mode != invalid && !allBoolean(x.typ) {
			check.error(s.Cond, _InvalidCond, "non-boolean condition in if statement")
		}
		check.stmt(inner, s.Body)
		// 解析器生成正确的AST，但如果它被修改
		// 其他地方的else分支可能无效。再查一遍。
		switch s.Else.(type) {
		case nil, *ast.BadStmt:
			// 有效或已报告错误
		case *ast.IfStmt, *ast.BlockStmt:
			check.stmt(inner, s.Else)
		default:
			check.invalidAST(s.Else, "invalid else branch in if statement")
		}

	case *ast.SwitchStmt:
		inner |= breakOk
		check.openScope(s, "switch")
		defer check.closeScope()

		check.simpleStmt(s.Init)
		var x operand
		if s.Tag != nil {
			check.expr(&x, s.Tag)
			// 通过检查x对不可见临时
			// （正如编译器所做的那样），我们得到了所有相关检查。
			check.assignment(&x, nil, "switch expression")
			if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) {
				check.errorf(&x, _InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ)
				x.mode = invalid
			}
		} else {
			// 规范：“缺少的开关表达式是
			// 等效于布尔值true。”
			x.mode = constant_
			x.typ = Typ[Bool]
			x.val = constant.MakeBool(true)
			x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
		}

		check.multipleDefaults(s.Body.List)

		seen := make(valueMap) // SEED大小写值到位置和类型的映射
		for i, c := range s.Body.List {
			clause, _ := c.(*ast.CaseClause)
			if clause == nil {
				check.invalidAST(c, "incorrect expression switch case")
				continue
			}
			check.caseValues(&x, clause.List, seen)
			check.openScope(clause, "case")
			inner := inner
			if i+1 < len(s.Body.List) {
				inner |= fallthroughOk
			} else {
				inner |= finalSwitchCase
			}
			check.stmtList(inner, clause.Body)
			check.closeScope()
		}

	case *ast.TypeSwitchStmt:
		inner |= breakOk
		check.openScope(s, "type switch")
		defer check.closeScope()

		check.simpleStmt(s.Init)

		// 类型开关保护必须采用以下格式：
		// 
		// TypeSwitchGuard=[identifier]：=“]PrimaryExpr”（“类型”）。
		// 
		// 解析器正在检查语法正确性；
		// 剩余的语法错误在这里被视为AST错误。
		// TODO（gri）更好地分解错误处理（无效AST）
		// 
		var lhs *ast.Ident // lhs标识符或nil 
		var rhs ast.Expr
		switch guard := s.Assign.(type) {
		case *ast.ExprStmt:
			rhs = guard.X
		case *ast.AssignStmt:
			if len(guard.Lhs) != 1 || guard.Tok != token.DEFINE || len(guard.Rhs) != 1 {
				check.invalidAST(s, "incorrect form of type switch guard")
				return
			}

			lhs, _ = guard.Lhs[0].(*ast.Ident)
			if lhs == nil {
				check.invalidAST(s, "incorrect form of type switch guard")
				return
			}

			if lhs.Name == "_" {
				// x（type）是无效的短变量声明
				check.softErrorf(lhs, _NoNewVar, "no new variable on left side of :=")
				lhs = nil // 
			} else {
				check.recordDef(lhs, nil) // lhs变量隐式声明在每个原因子句
			}

			rhs = guard.Rhs[0]

		default:
			check.invalidAST(s, "incorrect form of type switch guard")
			return
		}

		// rhs必须形式：expr。（type）和expr必须是一个普通的接口
		expr, _ := rhs.(*ast.TypeAssertExpr)
		if expr == nil || expr.Type != nil {
			check.invalidAST(s, "incorrect form of type switch guard")
			return
		}
		var x operand
		check.expr(&x, expr.X)
		if x.mode == invalid {
			return
		}
		// TODO（gri）我们可能希望允许在某个点上对类型参数值进行类型切换
		var sx *operand // switch表达式，根据这些表达式比较案例；nil if invalid 
		if isTypeParam(x.typ) {
			check.errorf(&x, _InvalidTypeSwitch, "cannot use type switch on type parameter value %s", &x)
		} else {
			if _, ok := under(x.typ).(*Interface); ok {
				sx = &x
			} else {
				check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x)
			}
		}

		check.multipleDefaults(s.Body.List)

		var lhsVars []*Var              // 隐式声明的lhs变量列表
		seen := make(map[Type]ast.Expr) // 看到的类型到位置的映射
		for _, s := range s.Body.List {
			clause, _ := s.(*ast.CaseClause)
			if clause == nil {
				check.invalidAST(s, "incorrect type switch case")
				continue
			}
			// 检查此类型开关中的每个类型。
			T := check.caseTypes(sx, clause.List, seen)
			check.openScope(clause, "case")
			// 如果lhs存在，在case local scope中声明一个相应的变量。
			if lhs != nil {
				// 规格：“TypeSwitchGuard可能包含一个简短的变量声明。使用该格式时，变量在每个子句中的隐式块的开头声明。在大小写为
				// 的子句中，只有一个类型的变量具有该类型；否则，变量
				// 具有类型中表达式的类型。”女巫守卫。“
				if len(clause.List) != 1 || T == nil {
					T = x.typ
				}
				obj := NewVar(lhs.Pos(), check.pkg, lhs.Name, T)
				scopePos := clause.Pos() + token.Pos(len("default")) // for default子句（len（List）=0）
				if n := len(clause.List); n > 0 {
					scopePos = clause.List[n-1].End()
				}
				check.declare(check.scope, nil, obj, scopePos)
				check.recordImplicit(clause, obj)
				// for the”声明但未使用“错误，所有lhs变量都充当
				// 一个；也就是说，如果其中任何一个被‘使用’，所有的变量都被‘使用’。
				// 收集它们以供以后分析。
				lhsVars = append(lhsVars, obj)
			}
			check.stmtList(inner, clause.Body)
			check.closeScope()
		}

		// 如果lhs存在，我们必须至少有一个使用过的lhs变量。
		if lhs != nil {
			var used bool
			for _, v := range lhsVars {
				if v.used {
					used = true
				}
				v.used = true // 在检查整个函数时避免使用错误
			}
			if !used {
				check.softErrorf(lhs, _UnusedVar, "%s declared but not used", lhs.Name)
			}
		}

	case *ast.SelectStmt:
		inner |= breakOk

		check.multipleDefaults(s.Body.List)

		for _, s := range s.Body.List {
			clause, _ := s.(*ast.CommClause)
			if clause == nil {
				continue // 在
			}

			valid := false
			var rhs ast.Expr // rhs of RecvStmt，或nil 
			switch s := clause.Comm.(type) {
			case nil, *ast.SendStmt:
				valid = true
			case *ast.AssignStmt:
				if len(s.Rhs) == 1 {
					rhs = s.Rhs[0]
				}
			case *ast.ExprStmt:
				rhs = s.X
			}

			// 如果存在，rhs必须是接收操作
			if rhs != nil {
				if x, _ := unparen(rhs).(*ast.UnaryExpr); x != nil && x.Op == token.ARROW {
					valid = true
				}
			}

			if !valid {
				check.error(clause.Comm, _InvalidSelectCase, "select case must be send or receive (possibly with assignment)")
				continue
			}

			check.openScope(s, "case")
			if clause.Comm != nil {
				check.stmt(inner, clause.Comm)
			}
			check.stmtList(inner, clause.Body)
			check.closeScope()
		}

	case *ast.ForStmt:
		inner |= breakOk | continueOk
		check.openScope(s, "for")
		defer check.closeScope()

		check.simpleStmt(s.Init)
		if s.Cond != nil {
			var x operand
			check.expr(&x, s.Cond)
			if x.mode != invalid && !allBoolean(x.typ) {
				check.error(s.Cond, _InvalidCond, "non-boolean condition in for statement")
			}
		}
		check.simpleStmt(s.Post)
		// spec:“init语句可以是短变量
		// 声明，但post语句不能。”
		if s, _ := s.Post.(*ast.AssignStmt); s != nil && s.Tok == token.DEFINE {
			check.softErrorf(s, _InvalidPostDecl, "cannot declare in post statement")
			// 不要在这里调用useLHS，因为我们想使用
			// 这个错误语句中的lhs，这样我们就不会得到关于
			// 这些lhs变量被声明但未被使用的错误。
			check.use(s.Lhs...) // 避免后续错误
		}
		check.stmt(inner, s.Body)

	case *ast.RangeStmt:
		inner |= breakOk | continueOk

		// 检查表达式以迭代
		var x operand
		check.expr(&x, s.X)

		// 确定键/值类型
		var key, val Type
		if x.mode != invalid {
			// 如果类型参数具有核心类型，则允许在该类型参数上进行测距。
			var cause string
			u := coreType(x.typ)
			switch t := u.(type) {
			case nil:
				cause = check.sprintf("%s has no core type", x.typ)
			case *Chan:
				if s.Value != nil {
					check.softErrorf(s.Value, _InvalidIterVar, "range over %s permits only one iteration variable", &x)
					// 确定继续
				}
				if t.dir == SendOnly {
					cause = "receive from send-only channel"
				}
			}
			key, val = rangeKeyVal(u)
			if key == nil || cause != "" {
				if cause == "" {
					check.softErrorf(&x, _InvalidRangeExpr, "cannot range over %s", &x)
				} else {
					check.softErrorf(&x, _InvalidRangeExpr, "cannot range over %s (%s)", &x, cause)
				}
				// 确定继续
			}
		}

		// 立即在range子句之后打开for语句块scope。
		// 用声明的迭代变量：=需要进入此范围（was问题#51437）。
		check.openScope(s, "range")
		defer check.closeScope()

		// 检查对迭代变量的赋值/声明
		// （不规则赋值，无法轻松映射到现有赋值检查）

		// lhs表达式和初始化值（rhs）类型
		lhs := [2]ast.Expr{s.Key, s.Value}
		rhs := [2]Type{key, val} // 键，val可能为零

		if s.Tok == token.DEFINE {
			// 短变量声明
			var vars []*Var
			for i, lhs := range lhs {
				if lhs == nil {
					continue
				}

				// 确定lhs变量
				var obj *Var
				if ident, _ := lhs.(*ast.Ident); ident != nil {
					// 声明新变量
					name := ident.Name
					obj = NewVar(ident.Pos(), check.pkg, name, nil)
					check.recordDef(ident, obj)
					// /uu变量不算作新变量
					if name != "_" {
						vars = append(vars, obj)
					}
				} else {
					check.invalidAST(lhs, "cannot declare %s", lhs)
					obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // 伪变量
				}

				// 初始化lhs变量
				if typ := rhs[i]; typ != nil {
					x.mode = value
					x.expr = lhs // 我们这里没有更好的rhs表达式
					x.typ = typ
					check.initVar(obj, &x, "range clause")
				} else {
					obj.typ = Typ[Invalid]
					obj.used = true // 不要抱怨未使用的变量
				}
			}

			// 声明变量
			if len(vars) > 0 {
				scopePos := s.Body.Pos()
				for _, obj := range vars {
					check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
				}
			} else {
				check.error(inNode(s, s.TokPos), _NoNewVar, "no new variables on left side of :=")
			}
		} else {
			// 普通赋值
			for i, lhs := range lhs {
				if lhs == nil {
					continue
				}
				if typ := rhs[i]; typ != nil {
					x.mode = value
					x.expr = lhs // 这里没有更好的rhs表达式
					x.typ = typ
					check.assignVar(lhs, &x)
				}
			}
		}

		check.stmt(inner, s.Body)

	default:
		check.invalidAST(s, "invalid statement")
	}
}

// rangeKeyVal返回range子句
// 在typ类型的表达式上生成的键和值类型。如果range子句不允许
// 则结果为零。
func rangeKeyVal(typ Type) (key, val Type) {
	switch typ := arrayPtrDeref(typ).(type) {
	case *Basic:
		if isString(typ) {
			return Typ[Int], universeRune // 使用“符文”名称
		}
	case *Array:
		return Typ[Int], typ.elem
	case *Slice:
		return Typ[Int], typ.elem
	case *Map:
		return typ.key, typ.elem
	case *Chan:
		return typ.elem, Typ[Invalid]
	}
	return
}
